/*
	CDRM3.h

	Copyright (C) 2004 WildTangent, Inc. 
	All Rights Reserved

	Travis Baldree
	8/24/2004

*/

#ifndef DRM3_H
#define DRM3_H

#include "drm3license.h"
#include "drmmacros.h"

#include "..\UTILITIES\Macros.h"
#include "..\UTILITIES\constants.h"


#ifdef _KEYHOLE
#include "..\..\..\SDK\_RANGER/ranger.h"
#endif



class CDRM3
{
public:

	///////////////////////////////////////////////////////////////////////////////////////
	//	Constants.
	///////////////////////////////////////////////////////////////////////////////////////
	enum
	{
		DRM3_APPTYPE_FULL = 1,
		DRM3_APPTYPE_DOWNLOADDEMO,
		DRM3_APPTYPE_ONLINEDEMO,
	};


	///////////////////////////////////////////////////////////////////////////////////////
	//	Constructor.
	///////////////////////////////////////////////////////////////////////////////////////
	CDRM3( const std::string&	CommandLine );	// command line parameters

	///////////////////////////////////////////////////////////////////////////////////////
	//	Destructor.
	///////////////////////////////////////////////////////////////////////////////////////
	~CDRM3( void );

	bool				LoadedSuccessfully( void )	{	return m_LoadedSuccessfully;	};

	const std::string&	ProductID( void )		{	return m_ProductID;			};

	const std::string&	DPID( void )			{	return m_DPID;				};

	const std::string&	ContentName( void )		{	return m_ContentName;		};

#ifndef _TRIMEDIA
#ifndef _TRIMEDIA_VERSION_52
#ifndef _KEYHOLE
	CDRM3License*		License( void )			{	return m_pLicense;			};
#endif
#endif
#endif

	uint32				ErrorCount( void )		{	return m_UpsellErrorCount;	};

	const std::string&	ErrorMessage( uint32 Index )	{	return m_UpsellError[Index];		};

	bool				Online( void )			{	return m_OnlineVersion;		};

	bool				UseLeaderboard( void )	{	return m_UseLeaderboard;	};
	bool				UseTracking( void )		{	return m_UseTracking;		};
	bool				LaunchWindowed( void )	{	return m_LaunchWindowed;	};

	///////////////////////////////////////////////////////////////////////////////////////
	//	Gets data from the clipboard.
	///////////////////////////////////////////////////////////////////////////////////////
	void InitLicense( void );

	///////////////////////////////////////////////////////////////////////////////////////
	//	Unlock the game.
	///////////////////////////////////////////////////////////////////////////////////////
	bool UnlockGame( void );

	///////////////////////////////////////////////////////////////////////////////////////
	//	Updates session data.
	///////////////////////////////////////////////////////////////////////////////////////
	void DecrementSessionCount( void );

	///////////////////////////////////////////////////////////////////////////////////////
	//	Spawns the buy webpage.
	///////////////////////////////////////////////////////////////////////////////////////
	void SpawnBuyPage( void );

	//	Spawns the upsell page.
	///////////////////////////////////////////////////////////////////////////////////////
	void SpawnUpsellPage( void );

	///////////////////////////////////////////////////////////////////////////////////////
	//	View online scores.
	///////////////////////////////////////////////////////////////////////////////////////
	void ViewScores( void );

	///////////////////////////////////////////////////////////////////////////////////////
	//	Post score online.
	///////////////////////////////////////////////////////////////////////////////////////
	void PostScore( int32 LevelIndex,	// index of level (0-based)
					int32 Score );		// score to post

	///////////////////////////////////////////////////////////////////////////////////////
	//	Handles render events.
	///////////////////////////////////////////////////////////////////////////////////////
	void Render( int32 ElapsedMS );	// elapsed number of ms

	void SetUnlockCode( const std::string& UnlockCode )		{	m_UnlockCode = UnlockCode;	};

#ifdef _KEYHOLE
	bool IsGameLocked( void );		// Get locked status for keyhole
#endif

private:
	///////////////////////////////////////////////////////////////////////////////////////
	//	Locals.
	///////////////////////////////////////////////////////////////////////////////////////
	int32		m_UpsellErrorCount;

	bool		m_UseLeaderboard;

	std::string	m_UnlockCode;
	std::string	m_UpsellError[4];
	
	///////////////////////////////////////////////////////////////////////////////////////
	//	Locals.
	///////////////////////////////////////////////////////////////////////////////////////
#ifdef _TRIMEDIA
	// doesn't do anything
#elif _KEYHOLE

	///////////////////////////////////////////////////////////////////////////////////////
	//	Do ranger related stuff.
	///////////////////////////////////////////////////////////////////////////////////////
	void ProcessRanger( WTR_Mode Mode );	// ranger mode

#else

	
	CDRM3License*	m_pLicense;


#endif

	bool			m_LoadedSuccessfully;
	bool			m_OnlineVersion;
	bool			m_UseTracking;
	bool			m_LaunchWindowed;
	std::string		m_VersionString;
	std::string		m_ContentName;
	std::string		m_DPName;
	std::string		m_ProductID;
	std::string		m_ContentID;
	std::string		m_DPID;
	std::string		m_BuyURL;
	std::string		m_MoreInfoURL;
	std::string		m_Language;
	std::string		m_UpsellPage;

	///////////////////////////////////////////////////////////////////////////////////////
	//	Load product info.
	///////////////////////////////////////////////////////////////////////////////////////
	void LoadProdInfo( void );

	///////////////////////////////////////////////////////////////////////////////////////
	//	Encrypt a std::string.
	///////////////////////////////////////////////////////////////////////////////////////
	std::string Encrypt( const std::string&	Clear,	// std::string to encrypt
						 const std::string&	Key );	// key

	///////////////////////////////////////////////////////////////////////////////////////
	//	Twiddle a std::string, for encryption purposes.
	///////////////////////////////////////////////////////////////////////////////////////
	char*	XORFlip( const char*	ToFlip,		// std::string to mod
					 const char*	Key,		// key
					 int32			Length1,	// length of std::string to mod
					 int32			Length2 );	// length of key

	///////////////////////////////////////////////////////////////////////////////////////
	//	Encode a url std::string.
	///////////////////////////////////////////////////////////////////////////////////////
	char* URLEncode( const char *Source,	// std::string to encode
					 unsigned Max );		// max length

	///////////////////////////////////////////////////////////////////////////////////////
	//	Get hash value.
	///////////////////////////////////////////////////////////////////////////////////////
	int32 Hash( const char* Data,			// data std::string
					  int32	Length );		// its length


};	// CDRM3 class


#endif
